﻿//-------------------------------------------------------------------
//	Copyright (c) 2010-2013  Zhirnov Andrey
//	This file is part of the "UX Standard Lib" project.
//	See copyright notice in "UX_STL_Ext.h".
//-------------------------------------------------------------------

#ifndef _UXS_GLES_ENUMS_H
#define _UXS_GLES_ENUMS_H

#include "../opengles.h"
//#include "../../../stl_core/ux_stl_core.h"
#include "../../OS/OSTypes.h"

namespace UX_STL
{
namespace GLESshell
{
	using namespace gles;
	using namespace UXMath;

	typedef uint16		GLenum_t;

	
// ------------------------ Buffer Targets ----------------------- //

namespace gl_buffer
{
	enum	type	: GLenum_t
	{
		ARRAY				= GL_ARRAY_BUFFER,
		ELEMENT_ARRAY		= GL_ELEMENT_ARRAY_BUFFER,

		// renamed
		INDEX				= ELEMENT_ARRAY,
		VERTEX				= ARRAY,
		_UNKNOWN			= 0,
	};
}


// ------------------------- Query Targets ----------------------- //

namespace gl_query
{
	enum	type	: GLenum_t
	{
		ANY_SAMPLES_PASSED						= EXT_occlusion_query_boolean::GL_ANY_SAMPLES_PASSED,
		ANY_SAMPLES_PASSED_CONSERVATIVE			= EXT_occlusion_query_boolean::GL_ANY_SAMPLES_PASSED_CONSERVATIVE,
		_INIT									= 0,
	};
}


// ------------------------ Cube Map Face ------------------------ //

namespace gl_cube_face
{
	enum	type	: GLenum_t
	{
		POSITIVE_X	= GL_TEXTURE_CUBE_MAP_POSITIVE_X,
		NEGATIVE_X	= GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
		POSITIVE_Y	= GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
		NEGATIVE_Y	= GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
		POSITIVE_Z	= GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
		NEGATIVE_Z	= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
		_FIRST		= POSITIVE_X,
		_LAST		= NEGATIVE_Z,
		_INIT		= _FIRST,
		_UNKNOWN	= 0,
	};

	UX_ENUM_ADD_OPERATIONS( type )
}


// ------------------------ Texture Targets ---------------------- //

namespace gl_texture
{
	enum	type	: GLenum_t
	{
		TEXTURE_2D						= GL_TEXTURE_2D,
		TEXTURE_3D						= OES_texture_3D::GL_TEXTURE_3D,
		TEXTURE_CUBE_MAP				= GL_TEXTURE_CUBE_MAP,
		_INIT							= TEXTURE_2D,
		_UNKNOWN						= 0,

		// for creating CLimage //
		_CUBEFACE_POSITIVE_X			= GL_TEXTURE_CUBE_MAP_POSITIVE_X,
		_CUBEFACE_NEGATIVE_X			= GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
		_CUBEFACE_POSITIVE_Y			= GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
		_CUBEFACE_NEGATIVE_Y			= GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
		_CUBEFACE_POSITIVE_Z			= GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
		_CUBEFACE_NEGATIVE_Z			= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
		_CUBEFACE_FIRST					= _CUBEFACE_POSITIVE_X,
		_CUBEFACE_LAST					= _CUBEFACE_NEGATIVE_Z,

		// for render target
		_RENDER_BUFFER					= GL_RENDERBUFFER,
	};

	inline gl_cube_face::type ToCubeFace(type t)
	{
		ASSERT( t >= _CUBEFACE_FIRST && t <= _CUBEFACE_LAST );
		return (gl_cube_face::type)t;
	}

	UX_ENUM_ADD_OPERATIONS( type )
}


// ------------------------ Draw Buffer -------------------------- //

namespace gl_draw_buffer
{
	enum	type	: GLenum_t
	{
		NONE				= GL_NONE,
		FRONT				= GL_FRONT,
		BACK				= GL_BACK,
		FRONT_AND_BACK		= GL_FRONT_AND_BACK,
		_INIT				= NONE,
		_UNKNOWN			= type(-1),
	};
}


// ----------------------- System Buffer ------------------------- //
/*
namespace gl_system_buffer
{
	enum	type	: GLenum_t
	{
		NONE				= GL_NONE,
		DEPTH				= GL_DEPTH,
		STENCIL				= GL_STENCIL,
	};
}
*/

// ------------------------ Read Buffer -------------------------- //

namespace gl_read_buffer
{
	enum	type	: GLenum_t
	{
		NONE				= GL_NONE,
		FRONT				= GL_FRONT,
		BACK				= GL_BACK,
		FRONT_AND_BACK		= GL_FRONT_AND_BACK,
		COLOR_0				= GL_COLOR_ATTACHMENT0,
	};
}


// --------------------- Framebuffer Targets --------------------- //

namespace gl_fbo_target
{
	enum	type	: GLenum_t
	{
		FRAMEBUFFER			= GL_FRAMEBUFFER,
		_INIT				= FRAMEBUFFER,
		_UNKNOWN			= 0,
	};
}


// ---------------------- Framebuffer Objects -------------------- //

namespace gl_fbo_object
{
	enum	type :	GLenum_t
	{
		NONE			= GL_NONE,
		TEXTURE			= GL_TEXTURE,
		RENDERBUFFER	= GL_RENDERBUFFER,
	};
}


// ------------------------ Primitive Types ---------------------- //

namespace gl_primitive
{
	enum	type	: GLenum_t
	{
		POINT						= GL_POINTS,
		LINE						= GL_LINES,
		LINE_LOOP					= GL_LINE_LOOP,
		LINE_STRIP					= GL_LINE_STRIP,
		TRIANGLE					= GL_TRIANGLES,
		TRIANGLE_STRIP				= GL_TRIANGLE_STRIP,
		TRIANGLE_FAN				= GL_TRIANGLE_FAN,
		_UNKNOWN					= 0,
	};
}


// ------------------------ Blend Equation ----------------------- //

namespace gl_blend_equation
{
	enum	type	: GLenum_t
	{
		ADD					= GL_FUNC_ADD,				// S+D
		SUB					= GL_FUNC_SUBTRACT,			// S-D
		REV_SUB				= GL_FUNC_REVERSE_SUBTRACT,	// D-S
		MIN					= EXT_blend_minmax::GL_MIN,	// min(S,D)
		MAX					= EXT_blend_minmax::GL_MAX,	// max(S,D)
		_INIT				= ADD,
		_UNKNOWN			= 0,
	};
}


// ------------------------- Blend Func -------------------------- //

namespace gl_blend_func
{
	enum	type	: GLenum_t
	{
		ZERO						= GL_ZERO,						// 0
		ONE							= GL_ONE,						// 1
		SRC_COLOR					= GL_SRC_COLOR,					// src
		ONE_MINUS_SRC_COLOR			= GL_ONE_MINUS_SRC_COLOR,		// 1 - src
		DST_COLOR					= GL_DST_COLOR,					// dst
		ONE_MINUS_DST_COLOR			= GL_ONE_MINUS_DST_COLOR,		// 1 - dst
		SRC_ALPHA					= GL_SRC_ALPHA,					// src.a
		ONE_MINUS_SRC_ALPHA			= GL_ONE_MINUS_SRC_ALPHA,		// 1 - src.a
		DST_ALPHA					= GL_DST_ALPHA,					// dst.a
		ONE_MINUS_DST_ALPHA			= GL_ONE_MINUS_DST_ALPHA,		// 1 - dst.a
		CONST_COLOR					= GL_CONSTANT_COLOR,			// cc
		ONE_MINUS_CONST_COLOR		= GL_ONE_MINUS_CONSTANT_COLOR,	// 1 - cc
		CONST_ALPHA					= GL_CONSTANT_ALPHA,			// cc.a
		ONE_MINUS_CONST_ALPHA		= GL_ONE_MINUS_CONSTANT_ALPHA,	// 1 - cc.a
		SRC_ALPHA_SATURATE			= GL_SRC_ALPHA_SATURATE,		// rgb * min( src.a, dst.a ), a * 1
		//SRC1_COLOR				= GL_SRC1_COLOR,				// src1
		//SRC1_ALPHA				= GL_SRC1_ALPHA,				// src1.a
		//ONE_MINUS_SRC1_COLOR		= GL_ONE_MINUS_SRC1_COLOR,		// 1 - src1
		//ONE_MINUS_SRC1_ALPHA		= GL_ONE_MINUS_SRC1_ALPHA,		// 1 - src1.a
		_INIT						= ZERO,
		_UNKNOWN					= type(-1),
	};
}


// ------------------------ Compare Mode ------------------------- //

namespace gl_compare
{
	enum	type	: GLenum_t
	{
		NONE		= GL_NONE,		// (disable)
		NEVER		= GL_NEVER,		// false
		LESS		= GL_LESS,		// <
		EQUAL		= GL_EQUAL,		// ==
		LEQUAL		= GL_LEQUAL,	// <=
		GREATER		= GL_GREATER,	// >
		NOTEQUAL	= GL_NOTEQUAL,	// !=
		GEQUAL		= GL_GEQUAL,	// >=
		ALWAYS		= GL_ALWAYS,	// true
		_INIT		= LESS,
		_UNKNOWN	= 0,
	};
}


// ------------------------- Usage Mode -------------------------- //

namespace gl_usage
{
	enum	type	: GLenum_t
	{
		STREAM_DRAW		= GL_STREAM_DRAW,
		STATIC_DRAW		= GL_STATIC_DRAW,
		DYNAMIC_DRAW	= GL_DYNAMIC_DRAW,
		_UNKNOWN		= 0,
		
		// rename
		STREAM			= STREAM_DRAW,
		STATIC			= STATIC_DRAW,
		DYNAMIC			= DYNAMIC_DRAW,
	};
}


// ----------------------- Front Face ---------------------------- //

namespace gl_front_face
{
	enum	type	: GLenum_t
	{
		CW		= GL_CW,
		CCW		= GL_CCW,
		_INIT	= CCW,
	};
}


// -------------------------- Face ------------------------------- //

namespace gl_face
{
	enum	type	: GLenum_t
	{
		FRONT				= GL_FRONT,
		BACK				= GL_BACK,
		FRONT_AND_BACK		= GL_FRONT_AND_BACK,
		_INIT				= BACK,
	};
}


// ------------------ Enable / Disable Flags --------------------- //

namespace gl_state
{
	enum	type	: GLenum_t
	{
		TEXTURE_2D					= GL_TEXTURE_2D,
		BLEND						= GL_BLEND,
		CULL_FACE					= GL_CULL_FACE,
		DEPTH_TEST					= GL_DEPTH_TEST,
		DITHER						= GL_DITHER,
		SAMPLE_ALPHA_TO_COVERAGE	= GL_SAMPLE_ALPHA_TO_COVERAGE,
		SAMPLE_COVERAGE				= GL_SAMPLE_COVERAGE,
		SCISSOR_TEST				= GL_SCISSOR_TEST,
		STENCIL_TEST				= GL_STENCIL_TEST,
		POLYGON_OFFSET_FILL			= GL_POLYGON_OFFSET_FILL,
		_UNKNOWN					= 0,
	};
}


// ------------------------ Vertex Type -------------------------- //

namespace gl_vertex
{
	enum	type	: GLenum_t
	{
		BYTE						= GL_BYTE,
		UBYTE						= GL_UNSIGNED_BYTE,
		SHORT						= GL_SHORT,
		USHORT						= GL_UNSIGNED_SHORT,
		FLOAT						= GL_FLOAT,
		FIXED						= GL_FIXED,
		_UNKNOWN					= FLOAT,
	};
}


// ------------------------- Index Type -------------------------- //

namespace gl_index
{
	enum	type	: GLenum_t
	{
		UBYTE			= GL_UNSIGNED_BYTE,
		USHORT			= GL_UNSIGNED_SHORT,
		UINT			= OES_element_index_uint::GL_UNSIGNED_INT,

		UINT_8			= UBYTE,
		UINT_16			= USHORT,
		UINT_32			= UINT,
		
		_INIT			= USHORT,
		_UNKNOWN		= 0,
	};
}


// ------------------------- FBO Attach -------------------------- //

namespace gl_fbo_attach
{
	enum	type	: GLenum
	{
		NONE			= GL_NONE,
		DEPTH			= GL_DEPTH_ATTACHMENT,
		STENCIL			= GL_STENCIL_ATTACHMENT,
		COLOR_0			= GL_COLOR_ATTACHMENT0,
		_COLOR_FIRST	= COLOR_0,
		_COLOR_LAST		= COLOR_0,
		_INIT			= 0,
	};
	UX_ENUM_ADD_OPERATIONS( type );
}


// ------------------------- Uniform Type ------------------------ //

namespace gl_uniform
{
	enum	type	: GLenum_t
	{
		_UNKNOWN				= 0,

		// Bool //
		BOOL					= GL_BOOL,
		BOOL_VEC2				= GL_BOOL_VEC2,
		BOOL_VEC3				= GL_BOOL_VEC3,
		BOOL_VEC4				= GL_BOOL_VEC4,
		
		// Float //
		FLOAT					= GL_FLOAT,
		FLOAT_VEC2				= GL_FLOAT_VEC2,
		FLOAT_VEC3				= GL_FLOAT_VEC3,
		FLOAT_VEC4				= GL_FLOAT_VEC4,
		FLOAT_MAT2				= GL_FLOAT_MAT2,
		FLOAT_MAT3				= GL_FLOAT_MAT3,
		FLOAT_MAT4				= GL_FLOAT_MAT4,

		// Int //
		INT						= GL_INT,
		INT_VEC2				= GL_INT_VEC2,
		INT_VEC3				= GL_INT_VEC3,
		INT_VEC4				= GL_INT_VEC4,

		// Samplers //
		SAMPLER_2D						= GL_SAMPLER_2D,
		SAMPLER_3D						= OES_texture_3D::GL_SAMPLER_3D,
		SAMPLER_CUBE_MAP				= GL_SAMPLER_CUBE,
		SAMPLER_2D_SHADOW				= EXT_shadow_samplers::GL_SAMPLER_2D_SHADOW,
		//SAMPLER_CUBE_MAP_SHADOW			= EXT_shadow_samplers::GL_SAMPLER_CUBE_SHADOW,
	};
}


// ------------------------- Attrib Mask ------------------------- //

namespace gl_attrib_mask
{
	enum	type	: uint32
	{
		DEPTH		= GL_DEPTH_BUFFER_BIT,
		STENCIL		= GL_STENCIL_BUFFER_BIT,
		COLOR		= GL_COLOR_BUFFER_BIT,
		ALL			= 0xFFFFFFFF,
		_INIT		= COLOR,
		_UNKNOWN	= 0,
	};

	UX_ENUM_BIT_OPERATIONS( type )
}


// ------------------------ Stencil Op --------------------------- //

namespace gl_stencil_op
{
	enum	type	: GLenum_t
	{
		KEEP		= GL_KEEP,
		ZERO		= GL_ZERO,
		REPLACE		= GL_REPLACE,
		INCR		= GL_INCR,
		INCR_WRAP	= GL_INCR_WRAP,
		DECR		= GL_DECR,
		DECR_WRAP	= GL_DECR_WRAP,
		INVERT		= GL_INVERT,
		_INIT		= KEEP,
		_UNKNOWN	= 0,
	};
}


//-------------------- Texture Internal Format --------------------//

namespace __gl_tex_iformat
{
	enum	type :	GLenum_t
	{
		_UNKNOWN					= 0,

		// unsigned normalized
		ALPHA8						= EXT_texture_storage::GL_ALPHA8,
		R8							= EXT_texture_storage::GL_R8,	// or EXT_texture_rg
		RG8							= EXT_texture_storage::GL_RG8,	// or EXT_texture_rg
		RGB8						= OES_rgb8_rgba8::GL_RGB8,
		RGB10						= EXT_texture_storage::GL_RGB10,
		RGBA4						= GL_RGBA4,
		RGB5_A1						= GL_RGB5_A1,
		R5_G6_B5					= GL_RGB565,
		RGBA8						= OES_rgb8_rgba8::GL_RGBA8,
		RGB10_A2					= EXT_texture_storage::GL_RGB10_A2,
		BGRA8						= EXT_texture_storage::GL_BGRA8,
		// float
		RGBA32F						= EXT_texture_storage::GL_RGBA32F,
		RGBA16F						= EXT_texture_storage::GL_RGBA16F,
		RGB32F						= EXT_texture_storage::GL_RGB32F,
		RGB16F						= EXT_texture_storage::GL_RGB16F,
		RG32F						= EXT_texture_storage::GL_RG32F,
		RG16F						= EXT_texture_storage::GL_RG16F,
		R32F						= EXT_texture_storage::GL_R32F,
		R16F						= EXT_texture_storage::GL_R16F,
		ALPHA32F					= EXT_texture_storage::GL_ALPHA32F,
		ALPHA16F					= EXT_texture_storage::GL_ALPHA16F,
		// depth
		DEPTH16						= GL_DEPTH_COMPONENT16,
		DEPTH24						= OES_depth24::GL_DEPTH_COMPONENT24,
		DEPTH32						= OES_depth32::GL_DEPTH_COMPONENT32,
		DEPTH24_STENCIL8			= OES_packed_depth_stencil::GL_DEPTH24_STENCIL8,
	};
}

namespace gl_tex_iformat
{
	using namespace __gl_tex_iformat;

	// compressed
	const type	ETC1_RGB8			= (type) OES_compressed_ETC1_RGB8_texture::GL_ETC1_RGB8;
	const type	PALETTE4_RGB8		= (type) OES_compressed_paletted_texture::GL_PALETTE4_RGB8;
	const type	PALETTE4_RGBA8		= (type) OES_compressed_paletted_texture::GL_PALETTE4_RGBA8;
	const type	PALETTE4_R5_G6_B5	= (type) OES_compressed_paletted_texture::GL_PALETTE4_R5_G6_B5;
	const type	PALETTE4_RGBA4		= (type) OES_compressed_paletted_texture::GL_PALETTE4_RGBA4;
	const type	PALETTE4_RGB5_A1	= (type) OES_compressed_paletted_texture::GL_PALETTE4_RGB5_A1;
	const type	PALETTE8_RGB8		= (type) OES_compressed_paletted_texture::GL_PALETTE8_RGB8;
	const type	PALETTE8_RGBA8		= (type) OES_compressed_paletted_texture::GL_PALETTE8_RGBA8;
	const type	PALETTE8_R5_G6_B5	= (type) OES_compressed_paletted_texture::GL_PALETTE8_R5_G6_B5;
	const type	PALETTE8_RGBA4		= (type) OES_compressed_paletted_texture::GL_PALETTE8_RGBA4;
	const type	PALETTE8_RGB5_A1	= (type) OES_compressed_paletted_texture::GL_PALETTE8_RGB5_A1;
}


// --------------------- Render Target Format -------------------- //

namespace gl_rt_format
{
	using namespace gl_tex_iformat;
	
	// stencil
	const type	STENCIL1			= (type) OES_stencil1::GL_STENCIL_INDEX1;
	const type	STENCIL4			= (type) OES_stencil4::GL_STENCIL_INDEX4;
	const type	STENCIL8			= (type) GL_STENCIL_INDEX8;
}


// ------------------------- Pixel Format ------------------------ //

namespace gl_pixel_format
{
	enum	type :	GLenum_t
	{
		_UNKNOWN					= 0,
		ALPHA						= GL_ALPHA,
		RED							= EXT_texture_rg::GL_RED,
		RG							= EXT_texture_rg::GL_RG,
		RGB							= GL_RGB,
		RGBA						= GL_RGBA,
		BGRA						= EXT_texture_format_BGRA8888::GL_BGRA,
		DEPTH						= GL_DEPTH_COMPONENT,
		DEPTH_STENCIL				= OES_packed_depth_stencil::GL_DEPTH_STENCIL,
	};
}


// ------------------------- Pixel Type -------------------------- //

namespace gl_pixel
{
	enum	type :	GLenum_t
	{
		_UNKNOWN				= 0,
		UBYTE					= GL_UNSIGNED_BYTE,
		USHORT_5_6_5			= GL_UNSIGNED_SHORT_5_6_5,
		USHORT_5_5_5_1			= GL_UNSIGNED_SHORT_5_5_5_1,
		USHORT_4_4_4_4			= GL_UNSIGNED_SHORT_4_4_4_4,
		HALF					= OES_texture_half_float::GL_HALF_FLOAT,
		UINT_24_8				= OES_packed_depth_stencil::GL_UNSIGNED_INT_24_8,
		FLOAT					= GL_FLOAT,
	};
}


// ---------------------- Texture Addressing --------------------- //

namespace gl_wrap
{
	enum	type :	GLenum_t
	{
		CLAMP			= GL_CLAMP_TO_EDGE,
		MIRRORED_REPEAT	= GL_MIRRORED_REPEAT,
		REPEAT			= GL_REPEAT,
		_INIT			= REPEAT,
		_UNKNOWN		= 0,
	};
}


// ----------------------- Texture Filtering --------------------- //

namespace gl_filter
{
	enum	type :	GLenum_t
	{
		// min & mag
		NEAREST					= GL_NEAREST,
		LINEAR					= GL_LINEAR,
		// min only
		NEAREST_MIPMAP_NEAREST	= GL_NEAREST_MIPMAP_NEAREST,
		LINEAR_MIPMAP_NEAREST	= GL_LINEAR_MIPMAP_NEAREST,
		NEAREST_MIPMAP_LINEAR	= GL_NEAREST_MIPMAP_LINEAR,
		LINEAR_MIPMAP_LINEAR	= GL_LINEAR_MIPMAP_LINEAR,
	};
}


// --------------------- Texture Component Type ------------------ //

namespace gl_tex_component
{
	enum type	: GLenum_t
	{
		NONE		= GL_NONE,
		UNORM		= EXT_color_buffer_half_float::GL_UNSIGNED_NORMALIZED,
		FLOAT		= GL_FLOAT,
		FIXED		= GL_FIXED,
		INT			= GL_INT,
		UINT		= GL_UNSIGNED_INT,
	};
}


// ------------------------ Shader Types ------------------------- //

namespace gl_shader
{
	enum	type :	GLenum
	{
		VERTEX				= GL_VERTEX_SHADER,
		FRAGMENT			= GL_FRAGMENT_SHADER,
		_UNKNOWN			= 0,
	};

	enum	bits :	uint
	{
		VERTEX_BIT			= EXT_separate_shader_objects::GL_VERTEX_SHADER_BIT,
		FRAGMENT_BIT		= EXT_separate_shader_objects::GL_FRAGMENT_SHADER_BIT,
		ALL					= 0xFFFFFFFF,
		_UNKNOWN_BIT		= 0,
	};

	enum	index : uint
	{
		VERTEX_IDX			= 0,
		FRAGMENT_IDX,
		_IDX_COUNT,
		_IDX_FIRST	= VERTEX_IDX,
	};

	inline type BitToType(bits b)
	{
		switch ( b )
		{
			case VERTEX_BIT	:			return VERTEX;
			case FRAGMENT_BIT :			return FRAGMENT;
		};
		WARNING("Unsupported shader bit or greater then one bit are not zero");
		return _UNKNOWN;
	}

	inline bits TypeToBit(type t)
	{
		switch ( t )
		{
			case VERTEX :				return VERTEX_BIT;
			case FRAGMENT :				return FRAGMENT_BIT;
		};
		WARNING("Unknown shader type");
		return _UNKNOWN_BIT;
	}

	inline bits IndexToBits(index i)
	{
		return bits(1 << i);
	}

	inline type IndexToType(index i)
	{
		return BitToType( IndexToBits( i ) );
	}

	UX_ENUM_BIT_OPERATIONS( bits );
	UX_ENUM_ADD_OPERATIONS( index );
}


// ---------------------- Shader Precision ----------------------- //

namespace gl_shader_precision
{
	enum	type :	GLenum_t
	{
		LOW_FLOAT		= GL_LOW_FLOAT,
        MEDIUM_FLOAT	= GL_MEDIUM_FLOAT,
        HIGH_FLOAT		= GL_HIGH_FLOAT,
        LOW_INT			= GL_LOW_INT,
        MEDIUM_INT		= GL_MEDIUM_INT,
        HIGH_INT		= GL_HIGH_INT,
	};
}
	
//-------------------------------------------------------------------

}	// GLESshell
}	// UX_STL

#endif	// _UXS_GLES_ENUMS_H
